﻿using System;
using System.Collections.Generic;

using System.Text;

namespace Rance.Battle
{
    class 军师AI : AI
    {
        public override AIResult Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            List<AIResult> list = new List<AIResult>();
            
            var result1 = 法术攻击Excute(角色, 队伍状况, 技能mgt);
            if (result1 != null)
                list.Add(result1);

            var result2 = 加速Excute(角色, 队伍状况, 技能mgt);
            if (result2 != null)
                list.Add(result2);

            var result3 = 鼓舞Excute(角色, 队伍状况, 技能mgt);
            if (result3 != null)
                list.Add(result3);

            var result4 = 削弱Excute(角色, 队伍状况, 技能mgt);
            if (result4 != null)
                list.Add(result4);

            if (list.Count == 1)
            {
                if (队伍状况.战场.AI乱数表.Hit(90))
                    return list[0];
            }
            else if (list.Count == 2)
            {
                if (队伍状况.战场.AI乱数表.Hit(50))
                    return list[0];
                else
                    return list[1];
            }

            return 弓箭射击Excute(角色, 队伍状况, 技能mgt);
        }

        private static 军师AI instance = new 军师AI();
        public static 军师AI GetInstance()
        {
            return instance;
        }

        protected AIResult 弓箭射击Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            var 弓箭射击 = 技能mgt.Get("弓箭射击");
            var 弓箭射击target = getTarget(ConvertSoloTarget(弓箭射击.TargetList), 队伍状况, 角色);
            result.Action = 弓箭射击.Name;
            result.TargetList.Add(弓箭射击target);

            return result;

        }

        private 角色 getTarget(List<角色> targetList, 队伍状况 队伍状况, 角色 角色)
        {
            //优先攻击"准备中"的敌人
            List<角色> tempList = targetList.FindAll(r => r.是否准备);
            if (tempList.Count == 1)
                return targetList[0];
            else if (tempList.Count > 1)
            {
                var value = 队伍状况.战场.AI乱数表.Random(0, tempList.Count);
                return tempList[value];
            }

            //撇除"步卒"敌人
            tempList.Clear();
            foreach (var item in targetList)
            {
                if (item.兵种.类型 == "步卒")
                    continue;

                tempList.Add(item);
            }

            if (tempList.Count != 0)
                targetList = tempList;

            if (targetList.Count == 1)
                return targetList[0];
            else
            {
                //优先攻击准备中的敌人

                List<角色> temp2List = new List<角色>();
                foreach (var item in tempList)
                {
                    if (item.是否准备)
                    {
                        tempList.Add(item);
                        break;
                    }
                }
                if (temp2List.Count == 1)
                    return temp2List[0];

                var value = 队伍状况.战场.AI乱数表.Random(0, targetList.Count);
                return targetList[value];
            }
        }

        protected AIResult 法术攻击Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("水淹七军"))
            {
                var 水淹七军 = 技能mgt.Get("水淹七军");
                if (水淹七军.TargetList[0].List.Count > 2)
                {
                    result.Action = 水淹七军.Name;
                    result.TargetList = 水淹七军.TargetList[0].List;

                    return result;
                }
            }

            return null;
        }

        protected AIResult 加速Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("伏兵之计1"))
            {
                var 伏兵之计 = 技能mgt.Get("伏兵之计1");
                var 上一个是敌人 = false;

                foreach (var item in 队伍状况.战场.行动顺序.List)
                {
                    if (队伍状况.队伍.成员List.Contains(item))
                    {
                        if (上一个是敌人)
                        {
                            result.Action = 伏兵之计.Name;
                            result.TargetList.Add(item);

                            return result;
                        }
                    }
                    else
                    {
                        上一个是敌人 = true;
                    }
                }

            }

            if (技能mgt.Has("伏兵之计2"))
            {
                var 伏兵之计 = 技能mgt.Get("伏兵之计2");
                if (伏兵之计.TargetList[0].List.Count > 2)
                {
                    result.Action = 伏兵之计.Name;
                    result.TargetList = 伏兵之计.TargetList[0].List;

                    return result;
                }
            }

            return null;
        }

        protected AIResult 鼓舞Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("全体鼓舞"))
            {
                var 全体鼓舞 = 技能mgt.Get("全体鼓舞");
                int 赋予比例 = get赋予比例(全体鼓舞.TargetList[0].List);

                if (赋予比例 < 38)
                {
                    result.Action = 全体鼓舞.Name;
                    result.TargetList = 全体鼓舞.TargetList[0].List;

                    return result;
                }
            }

            if (技能mgt.Has("鼓舞"))
            {
                var list = 队伍状况.队伍.成员List.FindAll(r => !r.是否败退);
                int 赋予比例 = get赋予比例(list);
                if (赋予比例 < 75)
                {
                    foreach (var item in list)
                    {
                        item.TempValue = 0;

                        if (item.是否完结)
                            item.TempValue += 5;

                        if (item.攻击赋予 != null)
                            item.TempValue++;
                        if (item.攻击诅咒 != null)
                            item.TempValue--;

                        if (item.防御赋予 != null)
                            item.TempValue++;
                        if (item.防御诅咒 != null)
                            item.TempValue--;

                        if (item.速度赋予 != null)
                            item.TempValue++;
                        if (item.速度诅咒 != null)
                            item.TempValue--;

                        if (item.智力赋予 != null)
                            item.TempValue++;
                        if (item.智力诅咒 != null)
                            item.TempValue--;
                    }

                    队伍状况.队伍.成员List.Sort((v1, v2) =>
                    {
                        var value = v1.TempValue.CompareTo(v2.TempValue);
                        if (value == 0)
                        {
                            return (v2.实际攻 + v2.实际防 + v2.实际速 + v2.实际智).CompareTo(v1.实际攻 + v1.实际防 + v1.实际速 + v1.实际智);
                        }
                        else
                            return value;
                    });

                    var 鼓舞 = 技能mgt.Get("鼓舞");
                    result.Action = 鼓舞.Name;
                    result.TargetList.Add(队伍状况.队伍.成员List[0]);

                    return result;
                }
            }

            return null;
        }

        private int get赋予比例(List<角色> list)
        {
            int total = list.Count * 4;
            int i = 0;

            foreach (var item in list)
            {
                if (item.攻击赋予 != null)
                    i++;
                if (item.防御赋予 != null)
                    i++;
                if (item.速度赋予 != null)
                    i++;
                if (item.智力赋予 != null)
                    i++;
            }

            return i * 100 / total;
        }

        protected AIResult 削弱Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("全体看破"))
            {
                var 全体看破 = 技能mgt.Get("全体看破");
                int 赋予比例 = get赋予比例(全体看破.TargetList[0].List);

                if (赋予比例 > 15)
                {
                    result.Action = 全体看破.Name;
                    result.TargetList = 全体看破.TargetList[0].List;

                    return result;
                }
            }

            if (技能mgt.Has("谣言"))
            {
                var 谣言 = 技能mgt.Get("谣言");
                int 诅咒比例 = get诅咒比例(谣言.TargetList[0].List);

                if (诅咒比例 < 50)
                {
                    result.Action = 谣言.Name;
                    result.TargetList = 谣言.TargetList[0].List;

                    return result;
                }
            }

            return null;
        }

        private int get诅咒比例(List<角色> list)
        {
            int total = list.Count * 4;
            int i = 0;

            foreach (var item in list)
            {
                if (item.攻击诅咒 != null)
                    i++;
                if (item.防御诅咒 != null)
                    i++;
                if (item.速度诅咒 != null)
                    i++;
                if (item.智力诅咒 != null)
                    i++;
            }

            return i * 100 / total;
        }
    }
}
